+Sun Oct 21 23:27:00 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.c (gtk_widget_translate_coordinates): Fix
+ problem with g_return_if_fail return value.
+
+ * gdk/x11/gdkproperty-x11.c docs/Changes-2.0.txt: Move over the
+ virtual atom code from the gdk-multihead branch, removing the per-display
+ part. Virtualizing atoms needs to be done now to prevent compat
+ breakage in direct Xlib accessing code in the future. (#62208)
+
+ * gdk/x11/gdkx.h: gdk/gdk/x11/gdkproperty-x11.c: Export
+ gdk_x11_xatom_to_atom, gdk_x11_atom_to_xatom().
+
+ * gdk/gdktypes.h docs/Changes-2.0.txt: Make GdkAtom
+ an opaque pointer type so the compiler catches attempts
+ to mingle it with X atoms.
+
+ * gdk/x11/{gdkdnd-x11.c,gdkevents-x11.c,gdkglobals-x11.c,
+ gdkkeys-x11.c, gdkmain-x11.c, gdkprivate-x11.c,
+ gdkproperty-x11.c, gdkselection-x11.c, gdkwindow-x11.c}
+ gtk/{gtkclist.c,gtkctree.c,gtkdnd.c,gtkplug.c,gtksocket.c}
+ tests/testdnd.c,tests/testselection.c:
+ Fix up for above atom changes.
+
+ * gdk/gdkselection.h (GDK_SELECTION_CLIPBOARD): Add, since we
+ now have the ability to add custom predefines.
+
+ * gtk/{gtkentry.c,gtklabel.c,gtkoldeditable.c,gtktextview.c}:
+ Use GDK_SELECTION_CLIPBOARD instead of GDK_NONE in calls
+ to gtk_clipboard_get().
+
+ * gdk/win32/gdkproperty-win32.c: Add CLIPBOARD, fix up
+ for GdkAtom => pointer change.
+
+ * gdk/linux-fb/gdkproperty-fb.c: Fix handling of predefined
+ atoms, fix for GdkAtom => pointer change.
+
Mon Oct 22 00:26:46 2001 Kristian Rietveld <kristian@planet.nl>
* gtk/gtkspinbutton.c: remove ARROW_SIZE constant, use
+Sun Oct 21 23:27:00 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.c (gtk_widget_translate_coordinates): Fix
+ problem with g_return_if_fail return value.
+
+ * gdk/x11/gdkproperty-x11.c docs/Changes-2.0.txt: Move over the
+ virtual atom code from the gdk-multihead branch, removing the per-display
+ part. Virtualizing atoms needs to be done now to prevent compat
+ breakage in direct Xlib accessing code in the future. (#62208)
+
+ * gdk/x11/gdkx.h: gdk/gdk/x11/gdkproperty-x11.c: Export
+ gdk_x11_xatom_to_atom, gdk_x11_atom_to_xatom().
+
+ * gdk/gdktypes.h docs/Changes-2.0.txt: Make GdkAtom
+ an opaque pointer type so the compiler catches attempts
+ to mingle it with X atoms.
+
+ * gdk/x11/{gdkdnd-x11.c,gdkevents-x11.c,gdkglobals-x11.c,
+ gdkkeys-x11.c, gdkmain-x11.c, gdkprivate-x11.c,
+ gdkproperty-x11.c, gdkselection-x11.c, gdkwindow-x11.c}
+ gtk/{gtkclist.c,gtkctree.c,gtkdnd.c,gtkplug.c,gtksocket.c}
+ tests/testdnd.c,tests/testselection.c:
+ Fix up for above atom changes.
+
+ * gdk/gdkselection.h (GDK_SELECTION_CLIPBOARD): Add, since we
+ now have the ability to add custom predefines.
+
+ * gtk/{gtkentry.c,gtklabel.c,gtkoldeditable.c,gtktextview.c}:
+ Use GDK_SELECTION_CLIPBOARD instead of GDK_NONE in calls
+ to gtk_clipboard_get().
+
+ * gdk/win32/gdkproperty-win32.c: Add CLIPBOARD, fix up
+ for GdkAtom => pointer change.
+
+ * gdk/linux-fb/gdkproperty-fb.c: Fix handling of predefined
+ atoms, fix for GdkAtom => pointer change.
+
Mon Oct 22 00:26:46 2001 Kristian Rietveld <kristian@planet.nl>
* gtk/gtkspinbutton.c: remove ARROW_SIZE constant, use
+Sun Oct 21 23:27:00 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.c (gtk_widget_translate_coordinates): Fix
+ problem with g_return_if_fail return value.
+
+ * gdk/x11/gdkproperty-x11.c docs/Changes-2.0.txt: Move over the
+ virtual atom code from the gdk-multihead branch, removing the per-display
+ part. Virtualizing atoms needs to be done now to prevent compat
+ breakage in direct Xlib accessing code in the future. (#62208)
+
+ * gdk/x11/gdkx.h: gdk/gdk/x11/gdkproperty-x11.c: Export
+ gdk_x11_xatom_to_atom, gdk_x11_atom_to_xatom().
+
+ * gdk/gdktypes.h docs/Changes-2.0.txt: Make GdkAtom
+ an opaque pointer type so the compiler catches attempts
+ to mingle it with X atoms.
+
+ * gdk/x11/{gdkdnd-x11.c,gdkevents-x11.c,gdkglobals-x11.c,
+ gdkkeys-x11.c, gdkmain-x11.c, gdkprivate-x11.c,
+ gdkproperty-x11.c, gdkselection-x11.c, gdkwindow-x11.c}
+ gtk/{gtkclist.c,gtkctree.c,gtkdnd.c,gtkplug.c,gtksocket.c}
+ tests/testdnd.c,tests/testselection.c:
+ Fix up for above atom changes.
+
+ * gdk/gdkselection.h (GDK_SELECTION_CLIPBOARD): Add, since we
+ now have the ability to add custom predefines.
+
+ * gtk/{gtkentry.c,gtklabel.c,gtkoldeditable.c,gtktextview.c}:
+ Use GDK_SELECTION_CLIPBOARD instead of GDK_NONE in calls
+ to gtk_clipboard_get().
+
+ * gdk/win32/gdkproperty-win32.c: Add CLIPBOARD, fix up
+ for GdkAtom => pointer change.
+
+ * gdk/linux-fb/gdkproperty-fb.c: Fix handling of predefined
+ atoms, fix for GdkAtom => pointer change.
+
Mon Oct 22 00:26:46 2001 Kristian Rietveld <kristian@planet.nl>
* gtk/gtkspinbutton.c: remove ARROW_SIZE constant, use
+Sun Oct 21 23:27:00 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.c (gtk_widget_translate_coordinates): Fix
+ problem with g_return_if_fail return value.
+
+ * gdk/x11/gdkproperty-x11.c docs/Changes-2.0.txt: Move over the
+ virtual atom code from the gdk-multihead branch, removing the per-display
+ part. Virtualizing atoms needs to be done now to prevent compat
+ breakage in direct Xlib accessing code in the future. (#62208)
+
+ * gdk/x11/gdkx.h: gdk/gdk/x11/gdkproperty-x11.c: Export
+ gdk_x11_xatom_to_atom, gdk_x11_atom_to_xatom().
+
+ * gdk/gdktypes.h docs/Changes-2.0.txt: Make GdkAtom
+ an opaque pointer type so the compiler catches attempts
+ to mingle it with X atoms.
+
+ * gdk/x11/{gdkdnd-x11.c,gdkevents-x11.c,gdkglobals-x11.c,
+ gdkkeys-x11.c, gdkmain-x11.c, gdkprivate-x11.c,
+ gdkproperty-x11.c, gdkselection-x11.c, gdkwindow-x11.c}
+ gtk/{gtkclist.c,gtkctree.c,gtkdnd.c,gtkplug.c,gtksocket.c}
+ tests/testdnd.c,tests/testselection.c:
+ Fix up for above atom changes.
+
+ * gdk/gdkselection.h (GDK_SELECTION_CLIPBOARD): Add, since we
+ now have the ability to add custom predefines.
+
+ * gtk/{gtkentry.c,gtklabel.c,gtkoldeditable.c,gtktextview.c}:
+ Use GDK_SELECTION_CLIPBOARD instead of GDK_NONE in calls
+ to gtk_clipboard_get().
+
+ * gdk/win32/gdkproperty-win32.c: Add CLIPBOARD, fix up
+ for GdkAtom => pointer change.
+
+ * gdk/linux-fb/gdkproperty-fb.c: Fix handling of predefined
+ atoms, fix for GdkAtom => pointer change.
+
Mon Oct 22 00:26:46 2001 Kristian Rietveld <kristian@planet.nl>
* gtk/gtkspinbutton.c: remove ARROW_SIZE constant, use
+Sun Oct 21 23:27:00 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.c (gtk_widget_translate_coordinates): Fix
+ problem with g_return_if_fail return value.
+
+ * gdk/x11/gdkproperty-x11.c docs/Changes-2.0.txt: Move over the
+ virtual atom code from the gdk-multihead branch, removing the per-display
+ part. Virtualizing atoms needs to be done now to prevent compat
+ breakage in direct Xlib accessing code in the future. (#62208)
+
+ * gdk/x11/gdkx.h: gdk/gdk/x11/gdkproperty-x11.c: Export
+ gdk_x11_xatom_to_atom, gdk_x11_atom_to_xatom().
+
+ * gdk/gdktypes.h docs/Changes-2.0.txt: Make GdkAtom
+ an opaque pointer type so the compiler catches attempts
+ to mingle it with X atoms.
+
+ * gdk/x11/{gdkdnd-x11.c,gdkevents-x11.c,gdkglobals-x11.c,
+ gdkkeys-x11.c, gdkmain-x11.c, gdkprivate-x11.c,
+ gdkproperty-x11.c, gdkselection-x11.c, gdkwindow-x11.c}
+ gtk/{gtkclist.c,gtkctree.c,gtkdnd.c,gtkplug.c,gtksocket.c}
+ tests/testdnd.c,tests/testselection.c:
+ Fix up for above atom changes.
+
+ * gdk/gdkselection.h (GDK_SELECTION_CLIPBOARD): Add, since we
+ now have the ability to add custom predefines.
+
+ * gtk/{gtkentry.c,gtklabel.c,gtkoldeditable.c,gtktextview.c}:
+ Use GDK_SELECTION_CLIPBOARD instead of GDK_NONE in calls
+ to gtk_clipboard_get().
+
+ * gdk/win32/gdkproperty-win32.c: Add CLIPBOARD, fix up
+ for GdkAtom => pointer change.
+
+ * gdk/linux-fb/gdkproperty-fb.c: Fix handling of predefined
+ atoms, fix for GdkAtom => pointer change.
+
Mon Oct 22 00:26:46 2001 Kristian Rietveld <kristian@planet.nl>
* gtk/gtkspinbutton.c: remove ARROW_SIZE constant, use
+Sun Oct 21 23:27:00 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.c (gtk_widget_translate_coordinates): Fix
+ problem with g_return_if_fail return value.
+
+ * gdk/x11/gdkproperty-x11.c docs/Changes-2.0.txt: Move over the
+ virtual atom code from the gdk-multihead branch, removing the per-display
+ part. Virtualizing atoms needs to be done now to prevent compat
+ breakage in direct Xlib accessing code in the future. (#62208)
+
+ * gdk/x11/gdkx.h: gdk/gdk/x11/gdkproperty-x11.c: Export
+ gdk_x11_xatom_to_atom, gdk_x11_atom_to_xatom().
+
+ * gdk/gdktypes.h docs/Changes-2.0.txt: Make GdkAtom
+ an opaque pointer type so the compiler catches attempts
+ to mingle it with X atoms.
+
+ * gdk/x11/{gdkdnd-x11.c,gdkevents-x11.c,gdkglobals-x11.c,
+ gdkkeys-x11.c, gdkmain-x11.c, gdkprivate-x11.c,
+ gdkproperty-x11.c, gdkselection-x11.c, gdkwindow-x11.c}
+ gtk/{gtkclist.c,gtkctree.c,gtkdnd.c,gtkplug.c,gtksocket.c}
+ tests/testdnd.c,tests/testselection.c:
+ Fix up for above atom changes.
+
+ * gdk/gdkselection.h (GDK_SELECTION_CLIPBOARD): Add, since we
+ now have the ability to add custom predefines.
+
+ * gtk/{gtkentry.c,gtklabel.c,gtkoldeditable.c,gtktextview.c}:
+ Use GDK_SELECTION_CLIPBOARD instead of GDK_NONE in calls
+ to gtk_clipboard_get().
+
+ * gdk/win32/gdkproperty-win32.c: Add CLIPBOARD, fix up
+ for GdkAtom => pointer change.
+
+ * gdk/linux-fb/gdkproperty-fb.c: Fix handling of predefined
+ atoms, fix for GdkAtom => pointer change.
+
Mon Oct 22 00:26:46 2001 Kristian Rietveld <kristian@planet.nl>
* gtk/gtkspinbutton.c: remove ARROW_SIZE constant, use
+Sun Oct 21 23:27:00 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.c (gtk_widget_translate_coordinates): Fix
+ problem with g_return_if_fail return value.
+
+ * gdk/x11/gdkproperty-x11.c docs/Changes-2.0.txt: Move over the
+ virtual atom code from the gdk-multihead branch, removing the per-display
+ part. Virtualizing atoms needs to be done now to prevent compat
+ breakage in direct Xlib accessing code in the future. (#62208)
+
+ * gdk/x11/gdkx.h: gdk/gdk/x11/gdkproperty-x11.c: Export
+ gdk_x11_xatom_to_atom, gdk_x11_atom_to_xatom().
+
+ * gdk/gdktypes.h docs/Changes-2.0.txt: Make GdkAtom
+ an opaque pointer type so the compiler catches attempts
+ to mingle it with X atoms.
+
+ * gdk/x11/{gdkdnd-x11.c,gdkevents-x11.c,gdkglobals-x11.c,
+ gdkkeys-x11.c, gdkmain-x11.c, gdkprivate-x11.c,
+ gdkproperty-x11.c, gdkselection-x11.c, gdkwindow-x11.c}
+ gtk/{gtkclist.c,gtkctree.c,gtkdnd.c,gtkplug.c,gtksocket.c}
+ tests/testdnd.c,tests/testselection.c:
+ Fix up for above atom changes.
+
+ * gdk/gdkselection.h (GDK_SELECTION_CLIPBOARD): Add, since we
+ now have the ability to add custom predefines.
+
+ * gtk/{gtkentry.c,gtklabel.c,gtkoldeditable.c,gtktextview.c}:
+ Use GDK_SELECTION_CLIPBOARD instead of GDK_NONE in calls
+ to gtk_clipboard_get().
+
+ * gdk/win32/gdkproperty-win32.c: Add CLIPBOARD, fix up
+ for GdkAtom => pointer change.
+
+ * gdk/linux-fb/gdkproperty-fb.c: Fix handling of predefined
+ atoms, fix for GdkAtom => pointer change.
+
Mon Oct 22 00:26:46 2001 Kristian Rietveld <kristian@planet.nl>
* gtk/gtkspinbutton.c: remove ARROW_SIZE constant, use
extern "C" {
#endif /* __cplusplus */
-/* The next three types define enums for predefined atoms relating
- to selections. In general, one will need to use gdk_intern_atom */
-
-typedef enum
-{
- GDK_SELECTION_PRIMARY = 1,
- GDK_SELECTION_SECONDARY = 2
-} GdkSelection;
-
-typedef enum
-{
- GDK_TARGET_BITMAP = 5,
- GDK_TARGET_COLORMAP = 7,
- GDK_TARGET_DRAWABLE = 17,
- GDK_TARGET_PIXMAP = 20,
- GDK_TARGET_STRING = 31
-} GdkTarget;
-
-typedef enum
-{
- GDK_SELECTION_TYPE_ATOM = 4,
- GDK_SELECTION_TYPE_BITMAP = 5,
- GDK_SELECTION_TYPE_COLORMAP = 7,
- GDK_SELECTION_TYPE_DRAWABLE = 17,
- GDK_SELECTION_TYPE_INTEGER = 19,
- GDK_SELECTION_TYPE_PIXMAP = 20,
- GDK_SELECTION_TYPE_WINDOW = 33,
- GDK_SELECTION_TYPE_STRING = 31
-} GdkSelectionType;
+/* Predefined atoms relating to selections. In general, one will need to use
+ * gdk_intern_atom
+ */
+#define GDK_SELECTION_PRIMARY _GDK_MAKE_ATOM (1)
+#define GDK_SELECTION_SECONDARY _GDK_MAKE_ATOM (2)
+#define GDK_SELECTION_CLIPBOARD _GDK_MAKE_ATOM (69)
+#define GDK_TARGET_BITMAP _GDK_MAKE_ATOM (5)
+#define GDK_TARGET_COLORMAP _GDK_MAKE_ATOM (7)
+#define GDK_TARGET_DRAWABLE _GDK_MAKE_ATOM (17)
+#define GDK_TARGET_PIXMAP _GDK_MAKE_ATOM (20)
+#define GDK_TARGET_STRING _GDK_MAKE_ATOM (3)
+#define GDK_SELECTION_TYPE_ATOM _GDK_MAKE_ATOM (4)
+#define GDK_SELECTION_TYPE_BITMAP _GDK_MAKE_ATOM (5)
+#define GDK_SELECTION_TYPE_COLORMAP _GDK_MAKE_ATOM (7)
+#define GDK_SELECTION_TYPE_DRAWABLE _GDK_MAKE_ATOM (17)
+#define GDK_SELECTION_TYPE_INTEGER _GDK_MAKE_ATOM (19)
+#define GDK_SELECTION_TYPE_PIXMAP _GDK_MAKE_ATOM (20)
+#define GDK_SELECTION_TYPE_WINDOW _GDK_MAKE_ATOM (33)
+#define GDK_SELECTION_TYPE_STRING _GDK_MAKE_ATOM (3)
+
+#ifndef GDK_DISABLE_DEPRECATED
+
+typedef GdkAtom GdkSelection;
+typedef GdkAtom GdkTarget;
+typedef GdkAtom GdkSelectionType;
+
+#endif /* GDK_DISABLE_DEPRECATED */
/* Selections
*/
#include <gdkconfig.h>
/* some common magic values */
-#define GDK_NONE 0L
#define GDK_CURRENT_TIME 0L
#define GDK_PARENT_RELATIVE 1L
* on Win32, wchar_t is unsigned short.
*/
typedef guint32 GdkWChar;
-typedef gulong GdkAtom;
+
+typedef struct _GdkAtom *GdkAtom;
+
+#define GDK_ATOM_TO_POINTER(atom) (atom)
+#define GDK_POINTER_TO_ATOM(ptr) ((GdkAtom)(ptr))
+
+#define _GDK_MAKE_ATOM(val) ((GdkAtom)GUINT_TO_POINTER(val))
+#define GDK_NONE _GDK_MAKE_ATOM (0)
#ifdef GDK_NATIVE_WINDOW_POINTER
typedef gpointer GdkNativeWindow;
{
g_return_val_if_fail (atom_name != NULL, GDK_NONE);
- return g_quark_from_string (atom_name);
+ if (strcmp (atom_name, "PRIMARY") == 0)
+ return GDK_SELECTION_PRIMARY;
+ else if (strcmp (atom_name, "SECONDARY") == 0)
+ return GDK_SELECTION_SECONDARY;
+ else if (strcmp (atom_name, "CLIPBOARD") == 0)
+ return GDK_SELECTION_CLIPBOARD;
+ else if (strcmp (atom_name, "ATOM") == 0)
+ return GDK_SELECTION_TYPE_ATOM;
+ else if (strcmp (atom_name, "BITMAP") == 0)
+ return GDK_SELECTION_TYPE_BITMAP;
+ else if (strcmp (atom_name, "COLORMAP") == 0)
+ return GDK_SELECTION_TYPE_COLORMAP;
+ else if (strcmp (atom_name, "DRAWABLE") == 0)
+ return GDK_SELECTION_TYPE_DRAWABLE;
+ else if (strcmp (atom_name, "INTEGER") == 0)
+ return GDK_SELECTION_TYPE_INTEGER;
+ else if (strcmp (atom_name, "PIXMAP") == 0)
+ return GDK_SELECTION_TYPE_PIXMAP;
+ else if (strcmp (atom_name, "WINDOW") == 0)
+ return GDK_SELECTION_TYPE_WINDOW;
+ else if (strcmp (atom_name, "STRING") == 0)
+ return GDK_SELECTION_TYPE_STRING;
+ else
+ return GUINT_TO_POINTER (256 + g_quark_from_string (atom_name));
}
gchar*
gdk_atom_name (GdkAtom atom)
{
- return g_strdup (g_quark_to_string (atom));
+ if (atom < 256)
+ {
+
+ switch (GPOINTER_TO_UINT (atom))
+ {
+ case GDK_SELECTION_PRIMARY: return g_strdup ("PRIMARY");
+ case GDK_SELECTION_SECONDARY: return g_strdup ("SECONDARY");
+ case GDK_SELECTION_CLIPBOARD: return g_strdup ("CLIPBOARD");
+ case GDK_SELECTION_TYPE_ATOM: return g_strdup ("ATOM");
+ case GDK_SELECTION_TYPE_BITMAP: return g_strdup ("BITMAP");
+ case GDK_SELECTION_TYPE_COLORMAP: return g_strdup ("COLORMAP");
+ case GDK_SELECTION_TYPE_DRAWABLE: return g_strdup ("DRAWABLE");
+ case GDK_SELECTION_TYPE_INTEGER: return g_strdup ("INTEGER");
+ case GDK_SELECTION_TYPE_PIXMAP: return g_strdup ("PIXMAP");
+ case GDK_SELECTION_TYPE_WINDOW: return g_strdup ("WINDOW");
+ case GDK_SELECTION_TYPE_STRING: return g_strdup ("STRING");
+ default:
+ g_warning (G_STRLOC "Invalid atom");
+ return g_strdup ("<invalid>");
+ }
+ }
+ else
+ return g_strdup (g_quark_to_string (atom - 256));
}
static void
{
GdkAtom retval;
static GHashTable *atom_hash = NULL;
+ ATOM win32_atom;
if (!atom_hash)
atom_hash = g_hash_table_new (g_str_hash, g_str_equal);
- retval = GPOINTER_TO_UINT (g_hash_table_lookup (atom_hash, atom_name));
+ retval = g_hash_table_lookup (atom_hash, atom_name);
if (!retval)
{
if (strcmp (atom_name, "PRIMARY") == 0)
retval = GDK_SELECTION_PRIMARY;
else if (strcmp (atom_name, "SECONDARY") == 0)
retval = GDK_SELECTION_SECONDARY;
+ else if (strcmp (atom_name, "CLIPBOARD") == 0)
+ retval = GDK_SELECTION_CLIPBOARD;
else if (strcmp (atom_name, "ATOM") == 0)
retval = GDK_SELECTION_TYPE_ATOM;
else if (strcmp (atom_name, "BITMAP") == 0)
retval = GDK_SELECTION_TYPE_STRING;
else
{
- retval = GlobalFindAtom (atom_name);
+ win32_atom = GlobalFindAtom (atom_name);
if (only_if_exists && retval == 0)
- retval = 0;
+ win32_atom = 0;
else
- retval = GlobalAddAtom (atom_name);
+ win32_atom = GlobalAddAtom (atom_name);
+ retval = GUINT_TO_POINTER (win32_atom);
}
g_hash_table_insert (atom_hash,
g_strdup (atom_name),
- GUINT_TO_POINTER (retval));
+ retval);
}
return retval;
gdk_atom_name (GdkAtom atom)
{
gchar name[256];
+ ATOM win32_atom;
switch (atom)
{
case GDK_SELECTION_PRIMARY: return g_strdup ("PRIMARY");
case GDK_SELECTION_SECONDARY: return g_strdup ("SECONDARY");
+ case GDK_SELECTION_CLIPBOARD: return g_strdup ("CLIPBOARD");
case GDK_SELECTION_TYPE_ATOM: return g_strdup ("ATOM");
case GDK_SELECTION_TYPE_BITMAP: return g_strdup ("BITMAP");
case GDK_SELECTION_TYPE_COLORMAP: return g_strdup ("COLORMAP");
case GDK_SELECTION_TYPE_WINDOW: return g_strdup ("WINDOW");
case GDK_SELECTION_TYPE_STRING: return g_strdup ("STRING");
}
- if (atom < 0xC000)
- return g_strdup_printf ("#%x", (guint) atom);
- else if (GlobalGetAtomName (atom, name, sizeof (name)) == 0)
+
+ win32_atom = GPOINTER_TO_UINT (atom);
+
+ if (win32_atom < 0xC000)
+ return g_strdup_printf ("#%x", atom);
+ else if (GlobalGetAtomName (win32_atom, name, sizeof (name)) == 0)
return NULL;
return g_strdup (name);
}
struct _GdkDragContextPrivateX11 {
GdkDragContext context;
- GdkAtom motif_selection;
- GdkAtom xdnd_selection;
+ Atom motif_selection;
+ Atom xdnd_selection;
guint ref_count;
guint16 last_x; /* Coordinates from last event */
static Atom wm_state_atom = None;
if (!wm_state_atom)
- wm_state_atom = gdk_atom_intern ("WM_STATE", FALSE);
+ wm_state_atom = gdk_x11_get_xatom_by_name ("WM_STATE");
XGetWindowProperty (gdk_display, win,
wm_state_atom, 0, 0, False, AnyPropertyType,
static Atom wm_state_atom = None;
if (!wm_state_atom)
- wm_state_atom = gdk_atom_intern ("WM_STATE", FALSE);
+ wm_state_atom = gdk_x11_get_xatom_by_name ("WM_STATE");
XGetWindowProperty (gdk_display, win,
wm_state_atom, 0, 0, False, AnyPropertyType,
{
while (targets)
{
- gchar *name = gdk_atom_name (GPOINTER_TO_INT (targets->data));
+ gchar *name = gdk_atom_name (GDK_POINTER_TO_ATOM (targets->data));
g_message ("\t%s", name);
g_free (name);
targets = targets->next;
static Window motif_drag_window = None;
static GdkWindow *motif_drag_gdk_window = NULL;
-static GdkAtom motif_drag_targets_atom = GDK_NONE;
-static GdkAtom motif_drag_receiver_info_atom = GDK_NONE;
+static Atom motif_drag_targets_atom = None;
+static Atom motif_drag_receiver_info_atom = None;
/* Target table handling */
return GDK_FILTER_REMOVE;
}
-static Atom motif_drag_window_atom = GDK_NONE;
+static Atom motif_drag_window_atom = None;
static Window
motif_lookup_drag_window (Display *display)
{
Window retval = None;
gulong bytes_after, nitems;
- GdkAtom type;
+ Atom type;
gint format;
guchar *data;
if (!motif_drag_window)
{
if (!motif_drag_window_atom)
- motif_drag_window_atom = gdk_atom_intern ("_MOTIF_DRAG_WINDOW", TRUE);
+ motif_drag_window_atom = gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_WINDOW");
motif_drag_window = motif_lookup_drag_window (gdk_display);
motif_read_target_table (void)
{
gulong bytes_after, nitems;
- GdkAtom type;
+ Atom type;
gint format;
gint i, j;
if (!motif_drag_targets_atom)
- motif_drag_targets_atom = gdk_atom_intern ("_MOTIF_DRAG_TARGETS", FALSE);
+ motif_drag_targets_atom = gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_TARGETS");
if (motif_target_lists)
{
}
static gint
-motif_add_to_target_table (GList *targets)
+motif_add_to_target_table (GList *targets) /* targets is list of GdkAtom */
{
GList *sorted = NULL;
gint index = -1;
while (targets)
{
- sorted = g_list_insert_sorted (sorted, targets->data, targets_sort_func);
+ Atom xatom = gdk_x11_atom_to_xatom (GDK_POINTER_TO_ATOM (targets->data));
+ sorted = g_list_insert_sorted (sorted, GUINT_TO_POINTER (xatom), targets_sort_func);
targets = targets->next;
}
GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
MotifDragInitiatorInfo info;
gint i;
- static GdkAtom motif_drag_initiator_info = GDK_NONE;
+ static Atom motif_drag_initiator_info = None;
if (!motif_drag_initiator_info)
- motif_drag_initiator_info = gdk_atom_intern ("_MOTIF_DRAG_INITIATOR_INFO", FALSE);
+ motif_drag_initiator_info = gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_INITIATOR_INFO");
info.byte_order = local_byte_order;
info.protocol_version = 0;
gchar buf[20];
g_snprintf(buf, 20, "_GDK_SELECTION_%d", i);
- private->motif_selection = gdk_atom_intern (buf, FALSE);
+ private->motif_selection = gdk_x11_get_xatom_by_name (buf);
if (!XGetSelectionOwner (gdk_display, private->motif_selection))
break;
}
unsigned long nitems, after;
if (!motif_drag_receiver_info_atom)
- motif_drag_receiver_info_atom = gdk_atom_intern ("_MOTIF_DRAG_RECEIVER_INFO", FALSE);
+ motif_drag_receiver_info_atom = gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_RECEIVER_INFO");
gdk_error_trap_push ();
XGetWindowProperty (gdk_display, win,
}
}
- return retval ? win : GDK_NONE;
-
+ return retval ? win : None;
}
static void
GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
xev.xclient.type = ClientMessage;
- xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_AND_DROP_MESSAGE");
xev.xclient.format = 8;
xev.xclient.window = GDK_DRAWABLE_XID (context->dest_window);
XEvent xev;
xev.xclient.type = ClientMessage;
- xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_AND_DROP_MESSAGE");
xev.xclient.format = 8;
xev.xclient.window = GDK_DRAWABLE_XID (context->dest_window);
GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
xev.xclient.type = ClientMessage;
- xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_AND_DROP_MESSAGE");
xev.xclient.format = 8;
xev.xclient.window = GDK_DRAWABLE_XID (context->dest_window);
GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
xev.xclient.type = ClientMessage;
- xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_AND_DROP_MESSAGE");
xev.xclient.format = 8;
xev.xclient.window = GDK_DRAWABLE_XID (context->dest_window);
/* Target Side */
static gboolean
-motif_read_initiator_info (Window source_window,
- Atom atom,
- GList **targets,
- GdkAtom *selection)
+motif_read_initiator_info (Window source_window,
+ Atom atom,
+ GList **targets, /* GdkAtom */
+ Atom *selection)
{
GList *tmp_list;
- static GdkAtom motif_drag_initiator_info = GDK_NONE;
- GdkAtom type;
+ static Atom motif_drag_initiator_info = None;
+ Atom type;
gint format;
gulong nitems;
gulong bytes_after;
MotifDragInitiatorInfo *initiator_info;
if (!motif_drag_initiator_info)
- motif_drag_initiator_info = gdk_atom_intern ("_MOTIF_DRAG_INITIATOR_INFO", FALSE);
+ motif_drag_initiator_info = gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_INITIATOR_INFO");
gdk_error_trap_push ();
XGetWindowProperty (gdk_display, source_window, atom,
*targets = NULL;
while (tmp_list)
{
- *targets = g_list_prepend (*targets,
- tmp_list->data);
+ GdkAtom atom = gdk_x11_xatom_to_atom (GPOINTER_TO_UINT (tmp_list->data));
+ *targets = g_list_prepend (*targets, GDK_ATOM_TO_POINTER (atom));
tmp_list = tmp_list->prev;
}
gdk_window_ref (dest_window);
new_context->start_time = timestamp;
- if (!motif_read_initiator_info(source_window,
- atom,
- &new_context->targets,
- &private->motif_selection))
+ if (!motif_read_initiator_info (source_window,
+ atom,
+ &new_context->targets,
+ &private->motif_selection))
{
gdk_drag_context_unref (new_context);
return NULL;
guint16 flags;
guint32 timestamp;
guint32 source_window;
- GdkAtom atom;
+ Atom atom;
gint16 x_root, y_root;
gboolean is_reply;
static struct {
gchar *name;
- GdkAtom atom;
+ Atom atom;
GdkDragAction action;
} xdnd_actions_table[] = {
- { "XdndActionCopy", GDK_NONE, GDK_ACTION_COPY },
- { "XdndActionMove", GDK_NONE, GDK_ACTION_MOVE },
- { "XdndActionLink", GDK_NONE, GDK_ACTION_LINK },
- { "XdndActionAsk", GDK_NONE, GDK_ACTION_ASK },
- { "XdndActionPrivate", GDK_NONE, GDK_ACTION_COPY },
+ { "XdndActionCopy", None, GDK_ACTION_COPY },
+ { "XdndActionMove", None, GDK_ACTION_MOVE },
+ { "XdndActionLink", None, GDK_ACTION_LINK },
+ { "XdndActionAsk", None, GDK_ACTION_ASK },
+ { "XdndActionPrivate", None, GDK_ACTION_COPY },
};
static const gint xdnd_n_actions = sizeof(xdnd_actions_table) / sizeof(xdnd_actions_table[0]);
xdnd_actions_initialized = TRUE;
for (i=0; i < xdnd_n_actions; i++)
- xdnd_actions_table[i].atom = gdk_atom_intern (xdnd_actions_table[i].name, FALSE);
+ xdnd_actions_table[i].atom = gdk_x11_get_xatom_by_name (xdnd_actions_table[i].name);
}
static GdkDragAction
-xdnd_action_from_atom (GdkAtom atom)
+xdnd_action_from_atom (Atom atom)
{
gint i;
return 0;
}
-static GdkAtom
+static Atom
xdnd_action_to_atom (GdkDragAction action)
{
gint i;
if (action == xdnd_actions_table[i].action)
return xdnd_actions_table[i].atom;
- return GDK_NONE;
+ return None;
}
-static GdkAtom xdnd_aware_atom = GDK_NONE;
+static Atom xdnd_aware_atom = None;
/* Source side */
XEvent *xevent = (XEvent *)xev;
guint32 dest_window = xevent->xclient.data.l[0];
guint32 flags = xevent->xclient.data.l[1];
- GdkAtom action = xevent->xclient.data.l[4];
+ Atom action = xevent->xclient.data.l[4];
GdkDragContext *context;
GDK_NOTE (DND,
xdnd_set_targets (GdkDragContext *context)
{
GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
- GdkAtom *atomlist;
+ Atom *atomlist;
GList *tmp_list = context->targets;
gint i;
gint n_atoms = g_list_length (context->targets);
- atomlist = g_new (GdkAtom, n_atoms);
+ atomlist = g_new (Atom, n_atoms);
i = 0;
while (tmp_list)
{
- atomlist[i] = GPOINTER_TO_INT (tmp_list->data);
+ atomlist[i] = gdk_x11_atom_to_xatom (GDK_POINTER_TO_ATOM (tmp_list->data));
tmp_list = tmp_list->next;
i++;
}
XChangeProperty (GDK_DRAWABLE_XDISPLAY (context->source_window),
GDK_DRAWABLE_XID (context->source_window),
- gdk_atom_intern ("XdndTypeList", FALSE),
+ gdk_x11_get_xatom_by_name ("XdndTypeList"),
XA_ATOM, 32, PropModeReplace,
(guchar *)atomlist, n_atoms);
xdnd_set_actions (GdkDragContext *context)
{
GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
- GdkAtom *atomlist;
+ Atom *atomlist;
gint i;
gint n_atoms;
guint actions;
}
}
- atomlist = g_new (GdkAtom, n_atoms);
+ atomlist = g_new (Atom, n_atoms);
actions = context->actions;
n_atoms = 0;
XChangeProperty (GDK_DRAWABLE_XDISPLAY (context->source_window),
GDK_DRAWABLE_XID (context->source_window),
- gdk_atom_intern ("XdndActionList", FALSE),
+ gdk_x11_get_xatom_by_name ("XdndActionList"),
XA_ATOM, 32, PropModeReplace,
(guchar *)atomlist, n_atoms);
GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
xev.xclient.type = ClientMessage;
- xev.xclient.message_type = gdk_atom_intern ("XdndEnter", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("XdndEnter");
xev.xclient.format = 32;
xev.xclient.window = private->drop_xid ?
private->drop_xid :
xev.xclient.data.l[4] = 0;
if (!private->xdnd_selection)
- private->xdnd_selection = gdk_atom_intern ("XdndSelection", FALSE);
+ private->xdnd_selection = gdk_x11_get_xatom_by_name ("XdndSelection");
if (g_list_length (context->targets) > 3)
{
while (tmp_list)
{
- xev.xclient.data.l[i] = GPOINTER_TO_INT (tmp_list->data);
+ xev.xclient.data.l[i] = gdk_x11_atom_to_xatom (GDK_POINTER_TO_ATOM (tmp_list->data));
tmp_list = tmp_list->next;
i++;
}
GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
xev.xclient.type = ClientMessage;
- xev.xclient.message_type = gdk_atom_intern ("XdndLeave", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("XdndLeave");
xev.xclient.format = 32;
xev.xclient.window = private->drop_xid ?
private->drop_xid :
XEvent xev;
xev.xclient.type = ClientMessage;
- xev.xclient.message_type = gdk_atom_intern ("XdndDrop", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("XdndDrop");
xev.xclient.format = 32;
xev.xclient.window = private->drop_xid ?
private->drop_xid :
XEvent xev;
xev.xclient.type = ClientMessage;
- xev.xclient.message_type = gdk_atom_intern ("XdndPosition", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("XdndPosition");
xev.xclient.format = 32;
xev.xclient.window = private->drop_xid ?
private->drop_xid :
Atom type = None;
int format;
unsigned long nitems, after;
- GdkAtom *version;
+ Atom *version;
Window *proxy_data;
Window proxy;
- static GdkAtom xdnd_proxy_atom = GDK_NONE;
+ static Atom xdnd_proxy_atom = None;
gint old_warnings = _gdk_error_warnings;
if (!xdnd_proxy_atom)
- xdnd_proxy_atom = gdk_atom_intern ("XdndProxy", FALSE);
+ xdnd_proxy_atom = gdk_x11_get_xatom_by_name ("XdndProxy");
if (!xdnd_aware_atom)
- xdnd_aware_atom = gdk_atom_intern ("XdndAware", FALSE);
+ xdnd_aware_atom = gdk_x11_get_xatom_by_name ("XdndAware");
- proxy = GDK_NONE;
+ proxy = None;
_gdk_error_code = 0;
_gdk_error_warnings = 0;
_gdk_error_warnings = old_warnings;
_gdk_error_code = 0;
- return retval ? (proxy ? proxy : win) : GDK_NONE;
+ return retval ? (proxy ? proxy : win) : None;
}
/* Target side */
XGetWindowProperty (GDK_DRAWABLE_XDISPLAY (context->source_window),
GDK_DRAWABLE_XID (context->source_window),
- gdk_atom_intern ("XdndActionList", FALSE), 0, 65536,
+ gdk_x11_get_xatom_by_name ("XdndActionList"), 0, 65536,
False, XA_ATOM, &type, &format, &nitems,
&after, (guchar **)&data);
GdkDragContext *context = cb_data;
if ((xevent->xany.type == PropertyNotify) &&
- (xevent->xproperty.atom == gdk_atom_intern ("XdndActionList", FALSE)))
+ (xevent->xproperty.atom == gdk_x11_get_xatom_by_name ("XdndActionList")))
{
xdnd_read_actions (context);
gdk_error_trap_push ();
XGetWindowProperty (GDK_DRAWABLE_XDISPLAY (event->any.window),
source_window,
- gdk_atom_intern ("XdndTypeList", FALSE), 0, 65536,
+ gdk_x11_get_xatom_by_name ("XdndTypeList"), 0, 65536,
False, XA_ATOM, &type, &format, &nitems,
&after, (guchar **)&data);
for (i=0; i<nitems; i++)
new_context->targets = g_list_append (new_context->targets,
- GUINT_TO_POINTER (data[i]));
+ GDK_ATOM_TO_POINTER (gdk_x11_xatom_to_atom (data[i])));
XFree(data);
}
for (i=0; i<3; i++)
if (xevent->xclient.data.l[2+i])
new_context->targets = g_list_append (new_context->targets,
- GUINT_TO_POINTER (xevent->xclient.data.l[2+i]));
+ GDK_ATOM_TO_POINTER (gdk_x11_xatom_to_atom (xevent->xclient.data.l[2+i])));
}
#ifdef G_ENABLE_DEBUG
current_dest_drag = new_context;
(PRIVATE_DATA (new_context))->xdnd_selection =
- gdk_atom_intern ("XdndSelection", FALSE);
+ gdk_x11_get_xatom_by_name ("XdndSelection");
return GDK_FILTER_TRANSLATE;
}
gint16 x_root = xevent->xclient.data.l[2] >> 16;
gint16 y_root = xevent->xclient.data.l[2] & 0xffff;
guint32 time = xevent->xclient.data.l[3];
- GdkAtom action = xevent->xclient.data.l[4];
+ Atom action = xevent->xclient.data.l[4];
GDK_NOTE (DND,
g_message ("XdndPosition: source_window: %#x position: (%d, %d) time: %d action: %ld",
gdk_drag_begin (GdkWindow *window,
GList *targets)
{
- GList *tmp_list;
GdkDragContext *new_context;
g_return_val_if_fail (window != NULL, NULL);
new_context->source_window = window;
gdk_window_ref (window);
- tmp_list = g_list_last (targets);
- new_context->targets = NULL;
- while (tmp_list)
- {
- new_context->targets = g_list_prepend (new_context->targets,
- tmp_list->data);
- tmp_list = tmp_list->prev;
- }
-
+ new_context->targets = g_list_copy (targets);
new_context->actions = 0;
return new_context;
_gdk_error_code = 0;
XGetWindowProperty (gdk_display, xid,
- gdk_atom_intern ("ENLIGHTENMENT_DESKTOP", FALSE),
+ gdk_x11_get_xatom_by_name ("ENLIGHTENMENT_DESKTOP"),
0, 0, False, AnyPropertyType,
&type, &format, &nitems, &after, &data);
if ((_gdk_error_code == 0) && type != None)
_gdk_error_code = 0;
XGetWindowProperty (gdk_display, win,
- gdk_atom_intern ("__SWM_VROOT", FALSE),
+ gdk_x11_get_xatom_by_name ("__SWM_VROOT"),
0, 0, False, AnyPropertyType,
&type, &format, &nitems, &data);
if ((_gdk_error_code == 0) && type != None)
}
*protocol = GDK_DRAG_PROTO_NONE;
- return GDK_NONE;
+ return None;
}
void
dest = get_client_window_at_coords (private->window_cache,
drag_window ?
- GDK_DRAWABLE_XID (drag_window) : GDK_NONE,
+ GDK_DRAWABLE_XID (drag_window) : None,
x_root, y_root);
if (private->dest_xid != dest)
GdkEvent temp_event;
if (g_list_find (context->targets,
- GUINT_TO_POINTER (gdk_atom_intern ("application/x-rootwin-drop", FALSE))))
+ GDK_ATOM_TO_POINTER (gdk_atom_intern ("application/x-rootwin-drop", FALSE))))
context->action = context->suggested_action;
else
context->action = 0;
if (context->protocol == GDK_DRAG_PROTO_MOTIF)
{
xev.xclient.type = ClientMessage;
- xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_AND_DROP_MESSAGE");
xev.xclient.format = 8;
xev.xclient.window = GDK_DRAWABLE_XID (context->source_window);
else if (context->protocol == GDK_DRAG_PROTO_XDND)
{
xev.xclient.type = ClientMessage;
- xev.xclient.message_type = gdk_atom_intern ("XdndStatus", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("XdndStatus");
xev.xclient.format = 32;
xev.xclient.window = GDK_DRAWABLE_XID (context->source_window);
XEvent xev;
xev.xclient.type = ClientMessage;
- xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_AND_DROP_MESSAGE");
xev.xclient.format = 8;
MOTIF_XCLIENT_BYTE (&xev, 0) = XmDROP_START | 0x80;
XEvent xev;
xev.xclient.type = ClientMessage;
- xev.xclient.message_type = gdk_atom_intern ("XdndFinished", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("XdndFinished");
xev.xclient.format = 32;
xev.xclient.window = GDK_DRAWABLE_XID (context->source_window);
/* Set Motif drag receiver information property */
if (!motif_drag_receiver_info_atom)
- motif_drag_receiver_info_atom = gdk_atom_intern ("_MOTIF_DRAG_RECEIVER_INFO", FALSE);
+ motif_drag_receiver_info_atom = gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_RECEIVER_INFO");
info.byte_order = local_byte_order;
info.protocol_version = 0;
info.protocol_style = XmDRAG_DYNAMIC;
- info.proxy_window = GDK_NONE;
+ info.proxy_window = None;
info.num_drop_sites = 0;
info.total_size = sizeof(info);
/* Set XdndAware */
if (!xdnd_aware_atom)
- xdnd_aware_atom = gdk_atom_intern ("XdndAware", FALSE);
+ xdnd_aware_atom = gdk_x11_get_xatom_by_name ("XdndAware");
/* The property needs to be of type XA_ATOM, not XA_INTEGER. Blech */
XChangeProperty (GDK_DRAWABLE_XDISPLAY (window),
g_return_val_if_fail (context != NULL, GDK_NONE);
if (context->protocol == GDK_DRAG_PROTO_MOTIF)
- return (PRIVATE_DATA (context))->motif_selection;
+ return gdk_x11_xatom_to_atom ((PRIVATE_DATA (context))->motif_selection);
else if (context->protocol == GDK_DRAG_PROTO_XDND)
- return (PRIVATE_DATA (context))->xdnd_selection;
+ return gdk_x11_xatom_to_atom ((PRIVATE_DATA (context))->xdnd_selection);
else
return GDK_NONE;
}
g_source_set_can_recurse (source, TRUE);
g_source_attach (source, NULL);
- _gdk_wm_window_protocols[0] = gdk_atom_intern ("WM_DELETE_WINDOW", FALSE);
- _gdk_wm_window_protocols[1] = gdk_atom_intern ("WM_TAKE_FOCUS", FALSE);
- _gdk_wm_window_protocols[2] = gdk_atom_intern ("_NET_WM_PING", FALSE);
+ _gdk_wm_window_protocols[0] = gdk_x11_get_xatom_by_name ("WM_DELETE_WINDOW");
+ _gdk_wm_window_protocols[1] = gdk_x11_get_xatom_by_name ("WM_TAKE_FOCUS");
+ _gdk_wm_window_protocols[2] = gdk_x11_get_xatom_by_name ("_NET_WM_PING");
gdk_add_client_message_filter (gdk_atom_intern ("WM_PROTOCOLS", FALSE),
gdk_wm_protocols_filter, NULL);
client_filters = g_list_prepend (client_filters, filter);
}
-static GdkAtom wm_state_atom = 0;
-static GdkAtom wm_desktop_atom = 0;
+static Atom wm_state_atom = 0;
+static Atom wm_desktop_atom = 0;
static void
gdk_check_wm_state_changed (GdkWindow *window)
gint format;
gulong nitems;
gulong bytes_after;
- GdkAtom *atoms = NULL;
+ Atom *atoms = NULL;
gulong i;
- GdkAtom sticky_atom;
- GdkAtom maxvert_atom;
- GdkAtom maxhorz_atom;
+ Atom sticky_atom;
+ Atom maxvert_atom;
+ Atom maxhorz_atom;
gboolean found_sticky, found_maxvert, found_maxhorz;
GdkWindowState old_state;
return;
if (wm_state_atom == 0)
- wm_state_atom = gdk_atom_intern ("_NET_WM_STATE", FALSE);
+ wm_state_atom = gdk_x11_get_xatom_by_name ("_NET_WM_STATE");
if (wm_desktop_atom == 0)
- wm_desktop_atom = gdk_atom_intern ("_NET_WM_DESKTOP", FALSE);
+ wm_desktop_atom = gdk_x11_get_xatom_by_name ("_NET_WM_DESKTOP");
XGetWindowProperty (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window),
wm_state_atom, 0, G_MAXLONG,
if (type != None)
{
- sticky_atom = gdk_atom_intern ("_NET_WM_STATE_STICKY", FALSE);
- maxvert_atom = gdk_atom_intern ("_NET_WM_STATE_MAXIMIZED_VERT", FALSE);
- maxhorz_atom = gdk_atom_intern ("_NET_WM_STATE_MAXIMIZED_HORZ", FALSE);
+ sticky_atom = gdk_x11_get_xatom_by_name ("_NET_WM_STATE_STICKY");
+ maxvert_atom = gdk_x11_get_xatom_by_name ("_NET_WM_STATE_MAXIMIZED_VERT");
+ maxhorz_atom = gdk_x11_get_xatom_by_name ("_NET_WM_STATE_MAXIMIZED_HORZ");
found_sticky = FALSE;
found_maxvert = FALSE;
case PropertyNotify:
GDK_NOTE (EVENTS,
- gchar *atom = gdk_atom_name (xevent->xproperty.atom);
g_message ("property notify:\twindow: %ld, atom(%ld): %s%s%s",
xevent->xproperty.window,
xevent->xproperty.atom,
- atom ? "\"" : "",
- atom ? atom : "unknown",
- atom ? "\"" : "");
- g_free (atom);
- );
+ "\"",
+ gdk_x11_get_xatom_name (xevent->xproperty.atom),
+ "\""));
if (window_private == NULL)
{
event->property.type = GDK_PROPERTY_NOTIFY;
event->property.window = window;
- event->property.atom = xevent->xproperty.atom;
+ event->property.atom = gdk_x11_xatom_to_atom (xevent->xproperty.atom);
event->property.time = xevent->xproperty.time;
event->property.state = xevent->xproperty.state;
if (wm_state_atom == 0)
- wm_state_atom = gdk_atom_intern ("_NET_WM_STATE", FALSE);
+ wm_state_atom = gdk_x11_get_xatom_by_name ("_NET_WM_STATE");
if (wm_desktop_atom == 0)
- wm_desktop_atom = gdk_atom_intern ("_NET_WM_DESKTOP", FALSE);
+ wm_desktop_atom = gdk_x11_get_xatom_by_name ("_NET_WM_DESKTOP");
- if (event->property.atom == wm_state_atom ||
- event->property.atom == wm_desktop_atom)
+ if (xevent->xproperty.atom == wm_state_atom ||
+ xevent->xproperty.atom == wm_desktop_atom)
{
/* If window state changed, then synthesize those events. */
gdk_check_wm_state_changed (event->property.window);
{
event->selection.type = GDK_SELECTION_CLEAR;
event->selection.window = window;
- event->selection.selection = xevent->xselectionclear.selection;
+ event->selection.selection = gdk_x11_xatom_to_atom (xevent->xselectionclear.selection);
event->selection.time = xevent->xselectionclear.time;
}
else
event->selection.type = GDK_SELECTION_REQUEST;
event->selection.window = window;
- event->selection.selection = xevent->xselectionrequest.selection;
- event->selection.target = xevent->xselectionrequest.target;
- event->selection.property = xevent->xselectionrequest.property;
+ event->selection.selection = gdk_x11_xatom_to_atom (xevent->xselectionrequest.selection);
+ event->selection.target = gdk_x11_xatom_to_atom (xevent->xselectionrequest.target);
+ event->selection.property = gdk_x11_xatom_to_atom (xevent->xselectionrequest.property);
event->selection.requestor = xevent->xselectionrequest.requestor;
event->selection.time = xevent->xselectionrequest.time;
event->selection.type = GDK_SELECTION_NOTIFY;
event->selection.window = window;
- event->selection.selection = xevent->xselection.selection;
- event->selection.target = xevent->xselection.target;
- event->selection.property = xevent->xselection.property;
+ event->selection.selection = gdk_x11_xatom_to_atom (xevent->xselection.selection);
+ event->selection.target = gdk_x11_xatom_to_atom (xevent->xselection.target);
+ event->selection.property = gdk_x11_xatom_to_atom (xevent->xselection.property);
event->selection.time = xevent->xselection.time;
break;
{
GList *tmp_list;
GdkFilterReturn result = GDK_FILTER_CONTINUE;
+ GdkAtom message_type = gdk_x11_xatom_to_atom (xevent->xclient.message_type);
GDK_NOTE (EVENTS,
g_message ("client message:\twindow: %ld",
while (tmp_list)
{
GdkClientFilter *filter = tmp_list->data;
- if (filter->type == xevent->xclient.message_type)
+ if (filter->type == message_type)
{
result = (*filter->function) (xevent, event, filter->data);
break;
{
event->client.type = GDK_CLIENT_EVENT;
event->client.window = window;
- event->client.message_type = xevent->xclient.message_type;
+ event->client.message_type = message_type;
event->client.data_format = xevent->xclient.format;
memcpy(&event->client.data, &xevent->xclient.data,
sizeof(event->client.data));
{
XEvent *xevent = (XEvent *)xev;
- if ((Atom) xevent->xclient.data.l[0] == gdk_atom_intern ("WM_DELETE_WINDOW", FALSE))
+ if ((Atom) xevent->xclient.data.l[0] == gdk_x11_get_xatom_by_name ("WM_DELETE_WINDOW"))
{
/* The delete window request specifies a window
* to delete. We don't actually destroy the
return GDK_FILTER_TRANSLATE;
}
- else if ((Atom) xevent->xclient.data.l[0] == gdk_atom_intern ("WM_TAKE_FOCUS", FALSE))
+ else if ((Atom) xevent->xclient.data.l[0] == gdk_x11_get_xatom_by_name ("WM_TAKE_FOCUS"))
{
GdkWindow *win = event->any.window;
Window focus_win = GDK_WINDOW_IMPL_X11(((GdkWindowObject *)win)->impl)->focus_window;
XSync (GDK_WINDOW_XDISPLAY (win), False);
gdk_error_trap_pop ();
}
- else if ((Atom) xevent->xclient.data.l[0] == gdk_atom_intern ("_NET_WM_PING", FALSE))
+ else if ((Atom) xevent->xclient.data.l[0] == gdk_x11_get_xatom_by_name ("_NET_WM_PING"))
{
XEvent xev = *xevent;
sev.xclient.format = event->client.data_format;
sev.xclient.window = xid;
memcpy(&sev.xclient.data, &event->client.data, sizeof(sev.xclient.data));
- sev.xclient.message_type = event->client.message_type;
+ sev.xclient.message_type = gdk_x11_atom_to_xatom (event->client.message_type);
return gdk_send_xevent (xid, False, NoEventMask, &sev);
}
guint32 xid,
guint level)
{
- static GdkAtom wm_state_atom = GDK_NONE;
+ static Atom wm_state_atom = None;
Atom type = None;
int format;
unsigned long nitems, after;
int i;
if (!wm_state_atom)
- wm_state_atom = gdk_atom_intern ("WM_STATE", FALSE);
+ wm_state_atom = gdk_x11_get_xatom_by_name ("WM_STATE");
_gdk_error_warnings = FALSE;
_gdk_error_code = 0;
sev.xclient.display = gdk_display;
sev.xclient.format = event->client.data_format;
memcpy(&sev.xclient.data, &event->client.data, sizeof(sev.xclient.data));
- sev.xclient.message_type = event->client.message_type;
+ sev.xclient.message_type = gdk_x11_atom_to_xatom (event->client.message_type);
gdk_event_send_client_message_to_all_recurse(&sev, _gdk_root_window, 0);
XSync (gdk_display, False);
}
-static GdkAtom timestamp_prop_atom = 0;
+static Atom timestamp_prop_atom = 0;
static Bool
timestamp_predicate (Display *display,
g_return_val_if_fail (!GDK_WINDOW_DESTROYED (window), 0);
if (!timestamp_prop_atom)
- timestamp_prop_atom = gdk_atom_intern ("GDK_TIMESTAMP_PROP", FALSE);
+ timestamp_prop_atom = gdk_x11_get_xatom_by_name ("GDK_TIMESTAMP_PROP");
xdisplay = GDK_WINDOW_XDISPLAY (window);
xwindow = GDK_WINDOW_XWINDOW (window);
gboolean
gdk_net_wm_supports (GdkAtom property)
{
- static GdkAtom wmspec_check_atom = 0;
- static GdkAtom wmspec_supported_atom = 0;
- static GdkAtom *atoms = NULL;
+ static Atom wmspec_check_atom = 0;
+ static Atom wmspec_supported_atom = 0;
+ static Atom *atoms = NULL;
static gulong n_atoms = 0;
+ Atom xproperty = gdk_x11_atom_to_xatom (property);
Atom type;
gint format;
gulong nitems;
i = 0;
while (i < n_atoms)
{
- if (atoms[i] == property)
+ if (atoms[i] == xproperty)
return TRUE;
++i;
*/
if (wmspec_check_atom == 0)
- wmspec_check_atom = gdk_atom_intern ("_NET_SUPPORTING_WM_CHECK", FALSE);
+ wmspec_check_atom = gdk_x11_get_xatom_by_name ("_NET_SUPPORTING_WM_CHECK");
if (wmspec_supported_atom == 0)
- wmspec_supported_atom = gdk_atom_intern ("_NET_SUPPORTED", FALSE);
+ wmspec_supported_atom = gdk_x11_get_xatom_by_name ("_NET_SUPPORTED");
XGetWindowProperty (gdk_display, _gdk_root_window,
wmspec_check_atom, 0, G_MAXLONG,
Window _gdk_root_window;
Window _gdk_leader_window;
Atom _gdk_wm_window_protocols[3];
-Atom _gdk_selection_property;
+GdkAtom _gdk_selection_property;
GdkWindowObject *_gdk_xgrab_window = NULL; /* Window that currently holds the
* x pointer grab
result = PANGO_DIRECTION_LTR;
else
{
- name = gdk_atom_name (xkb->names->groups[state_rec.locked_group]);
+ name = gdk_x11_get_xatom_name (xkb->names->groups[state_rec.locked_group]);
if (g_strcasecmp (name, "arabic") == 0 ||
g_strcasecmp (name, "hebrew") == 0 ||
g_strcasecmp (name, "israelian") == 0)
result = PANGO_DIRECTION_RTL;
else
result = PANGO_DIRECTION_LTR;
- g_free (name);
}
return result;
pid = getpid();
XChangeProperty (gdk_display, _gdk_leader_window,
- gdk_atom_intern ("_NET_WM_PID", FALSE),
+ gdk_x11_get_xatom_by_name ("_NET_WM_PID"),
XA_CARDINAL, 32,
PropModeReplace,
(guchar *)&pid, 1);
if (sm_client_id && strcmp (sm_client_id, ""))
{
XChangeProperty (gdk_display, _gdk_leader_window,
- gdk_atom_intern ("SM_CLIENT_ID", FALSE),
+ gdk_x11_get_xatom_by_name ("SM_CLIENT_ID"),
XA_STRING, 8, PropModeReplace,
sm_client_id, strlen(sm_client_id));
}
else
XDeleteProperty (gdk_display, _gdk_leader_window,
- gdk_atom_intern ("SM_CLIENT_ID", FALSE));
+ gdk_x11_get_xatom_by_name ("SM_CLIENT_ID"));
}
void
extern const int _gdk_nenvent_masks;
extern const int _gdk_event_mask_table[];
extern gint _gdk_screen;
-extern Atom _gdk_selection_property;
+extern GdkAtom _gdk_selection_property;
extern gchar *_gdk_display_name;
extern Window _gdk_leader_window;
#include <X11/Xatom.h>
#include <string.h>
+#include "gdk.h" /* For gdk_error_trap_push/pop() */
#include "gdkx.h"
#include "gdkproperty.h"
#include "gdkprivate.h"
-GdkAtom
-gdk_atom_intern (const gchar *atom_name,
- gboolean only_if_exists)
+static GPtrArray *virtual_atom_array;
+static GHashTable *virtual_atom_hash;
+static GHashTable *atom_to_virtual;
+static GHashTable *atom_from_virtual;
+
+static gchar *XAtomsStrings[] = {
+ /* These are all the standard predefined X atoms */
+ "NONE",
+ "PRIMARY",
+ "SECONDARY",
+ "ARC",
+ "ATOM",
+ "BITMAP",
+ "CARDINAL",
+ "COLORMAP",
+ "CURSOR",
+ "CUT_BUFFER0",
+ "CUT_BUFFER1",
+ "CUT_BUFFER2",
+ "CUT_BUFFER3",
+ "CUT_BUFFER4",
+ "CUT_BUFFER5",
+ "CUT_BUFFER6",
+ "CUT_BUFFER7",
+ "DRAWABLE",
+ "FONT",
+ "INTEGER",
+ "PIXMAP",
+ "POINT",
+ "RECTANGLE",
+ "RESOURCE_MANAGER",
+ "RGB_COLOR_MAP",
+ "RGB_BEST_MAP",
+ "RGB_BLUE_MAP",
+ "RGB_DEFAULT_MAP",
+ "RGB_GRAY_MAP",
+ "RGB_GREEN_MAP",
+ "RGB_RED_MAP",
+ "STRING",
+ "VISUALID",
+ "WINDOW",
+ "WM_COMMAND",
+ "WM_HINTS",
+ "WM_CLIENT_MACHINE",
+ "WM_ICON_NAME",
+ "WM_ICON_SIZE",
+ "WM_NAME",
+ "WM_NORMAL_HINTS",
+ "WM_SIZE_HINTS",
+ "WM_ZOOM_HINTS",
+ "MIN_SPACE",
+ "NORM_SPACE",
+ "MAX_SPACE", "END_SPACE",
+ "SUPERSCRIPT_X",
+ "SUPERSCRIPT_Y",
+ "SUBSCRIPT_X",
+ "SUBSCRIPT_Y",
+ "UNDERLINE_POSITION",
+ "UNDERLINE_THICKNESS",
+ "STRIKEOUT_ASCENT",
+ "STRIKEOUT_DESCENT",
+ "ITALIC_ANGLE",
+ "X_HEIGHT",
+ "QUAD_WIDTH",
+ "WEIGHT",
+ "POINT_SIZE",
+ "RESOLUTION",
+ "COPYRIGHT",
+ "NOTICE",
+ "FONT_NAME",
+ "FAMILY_NAME",
+ "FULL_NAME",
+ "CAP_HEIGHT",
+ "WM_CLASS",
+ "WM_TRANSIENT_FOR",
+ /* Below here, these our our additions. Increment N_CUSTOM_PREDEFINED
+ * if you add any.
+ */
+ "CLIPBOARD" /* = 69 */
+};
+
+#define N_CUSTOM_PREDEFINED 1
+
+#define ATOM_TO_INDEX(atom) (GPOINTER_TO_UINT(atom))
+#define INDEX_TO_ATOM(atom) ((GdkAtom)GUINT_TO_POINTER(atom))
+
+void
+insert_atom_pair (GdkAtom virtual_atom,
+ Atom xatom)
{
- GdkAtom retval;
- static GHashTable *atom_hash = NULL;
+ if (!atom_from_virtual)
+ {
+ atom_from_virtual = g_hash_table_new (g_direct_hash, NULL);
+ atom_to_virtual = g_hash_table_new (g_direct_hash, NULL);
+ }
- g_return_val_if_fail (atom_name != NULL, GDK_NONE);
-
- if (!atom_hash)
- atom_hash = g_hash_table_new (g_str_hash, g_str_equal);
+ g_hash_table_insert (atom_from_virtual,
+ GDK_ATOM_TO_POINTER (virtual_atom), GUINT_TO_POINTER (xatom));
+ g_hash_table_insert (atom_to_virtual,
+ GUINT_TO_POINTER (xatom), GDK_ATOM_TO_POINTER (virtual_atom));
+}
- retval = GPOINTER_TO_UINT (g_hash_table_lookup (atom_hash, atom_name));
- if (!retval)
+/**
+ * gdk_x11_atom_to_xatom:
+ * @atom: A #GdkAtom
+ *
+ * Convert from a #GdkAtom to the X atom for the default GDK display
+ * with the same string value.x
+ *
+ * Return value: the X atom corresponding to @atom.
+ **/
+Atom
+gdk_x11_atom_to_xatom (GdkAtom atom)
+{
+ Atom xatom = None;
+
+ if (ATOM_TO_INDEX (atom) < G_N_ELEMENTS (XAtomsStrings) - N_CUSTOM_PREDEFINED)
+ return ATOM_TO_INDEX (atom);
+
+ if (atom_from_virtual)
+ xatom = GPOINTER_TO_UINT (g_hash_table_lookup (atom_from_virtual,
+ GDK_ATOM_TO_POINTER (atom)));
+ if (!xatom)
{
- retval = XInternAtom (gdk_display, atom_name, only_if_exists);
+ char *name;
+
+ g_return_val_if_fail (ATOM_TO_INDEX (atom) < virtual_atom_array->len, None);
- if (retval != None)
- g_hash_table_insert (atom_hash,
- g_strdup (atom_name),
- GUINT_TO_POINTER (retval));
+ name = g_ptr_array_index (virtual_atom_array, ATOM_TO_INDEX (atom));
+
+ xatom = XInternAtom (gdk_display, name, FALSE);
+ insert_atom_pair (atom, xatom);
}
- return retval;
+ return xatom;
}
-gchar*
-gdk_atom_name (GdkAtom atom)
+/**
+ * gdk_x11_xatom_to_atom:
+ * @xatom: an X atom for the default GDK display
+ *
+ * Convert from an X atom for the default display to the corresponding
+ * #GdkAtom.
+ *
+ * Return value: the corresponding G#dkAtom.
+ **/
+GdkAtom
+gdk_x11_xatom_to_atom (Atom xatom)
{
- gchar *t;
- gchar *name;
- gint old_error_warnings;
-
- /* If this atom doesn't exist, we'll die with an X error unless
- we take precautions */
+ GdkAtom virtual_atom = GDK_NONE;
+
+ if (xatom < G_N_ELEMENTS (XAtomsStrings) - N_CUSTOM_PREDEFINED)
+ return INDEX_TO_ATOM (xatom);
+
+ if (atom_to_virtual)
+ virtual_atom = GDK_POINTER_TO_ATOM (g_hash_table_lookup (atom_to_virtual,
+ GUINT_TO_POINTER (xatom)));
+
+ if (!virtual_atom)
+ {
+ /* If this atom doesn't exist, we'll die with an X error unless
+ * we take precautions
+ */
+ char *name;
+ gdk_error_trap_push ();
+ name = XGetAtomName (gdk_display, xatom);
+ if (gdk_error_trap_pop ())
+ {
+ g_warning (G_STRLOC " invalid X atom: %ld", xatom);
+ }
+ else
+ {
+ virtual_atom = gdk_atom_intern (name, FALSE);
+ XFree (name);
+
+ insert_atom_pair (virtual_atom, xatom);
+ }
+ }
- old_error_warnings = _gdk_error_warnings;
- _gdk_error_warnings = 0;
- _gdk_error_code = 0;
- t = XGetAtomName (gdk_display, atom);
- _gdk_error_warnings = old_error_warnings;
+ return virtual_atom;
+}
- if (_gdk_error_code)
+static void
+virtual_atom_check_init (void)
+{
+ if (!virtual_atom_hash)
{
- if (t)
- XFree (t);
-
- return NULL;
+ gint i;
+
+ virtual_atom_hash = g_hash_table_new (g_str_hash, g_str_equal);
+ virtual_atom_array = g_ptr_array_new ();
+
+ for (i = 0; i < G_N_ELEMENTS (XAtomsStrings); i++)
+ {
+ g_ptr_array_add (virtual_atom_array, XAtomsStrings[i]);
+ g_hash_table_insert (virtual_atom_hash, XAtomsStrings[i],
+ GUINT_TO_POINTER (i));
+ }
}
- else
+}
+
+GdkAtom
+gdk_atom_intern (const gchar *atom_name,
+ gboolean only_if_exists)
+{
+ GdkAtom result;
+
+ virtual_atom_check_init ();
+
+ result = GDK_POINTER_TO_ATOM (g_hash_table_lookup (virtual_atom_hash, atom_name));
+ if (!result)
{
- name = g_strdup (t);
- if (t)
- XFree (t);
+ result = INDEX_TO_ATOM (virtual_atom_array->len);
- return name;
+ g_ptr_array_add (virtual_atom_array, g_strdup (atom_name));
+ g_hash_table_insert (virtual_atom_hash,
+ g_ptr_array_index (virtual_atom_array,
+ ATOM_TO_INDEX (result)),
+ GDK_ATOM_TO_POINTER (result));
}
+
+ return result;
+}
+
+static G_CONST_RETURN char *
+get_atom_name (GdkAtom atom)
+{
+ virtual_atom_check_init ();
+
+ if (ATOM_TO_INDEX (atom) < virtual_atom_array->len)
+ return g_strdup (g_ptr_array_index (virtual_atom_array, ATOM_TO_INDEX (atom)));
+ else
+ return NULL;
+}
+
+gchar *
+gdk_atom_name (GdkAtom atom)
+{
+ return g_strdup (get_atom_name (atom));
+}
+
+/**
+ * gdk_x11_get_xatom_by_name:
+ * @atom_name: a string
+ *
+ * Returns the X atom for GDK's default display corresponding to @atom_name.
+ * This function caches the result, so if called repeatedly it is much
+ * faster than XInternAtom, which is a round trip to the server each time.
+ *
+ * Return value: a X atom for GDK's default display.
+ **/
+Atom
+gdk_x11_get_xatom_by_name (const gchar *atom_name)
+{
+ return gdk_x11_atom_to_xatom (gdk_atom_intern (atom_name, FALSE));
+}
+
+/**
+ * gdk_x11_get_xatom_name:
+ * @xatom: an X atom for GDK's default display
+ *
+ * Returns the name of an X atom for GDK's default display. This
+ * function is meant mainly for debugging, so for convenience, unlike
+ * XAtomName() and gdk_atom_name(), the result doesn't need to
+ * be freed. Also, this function will never return %NULL, even
+ * if @xatom is invalid.
+ *
+ * Return value: name of the X atom; this string is owned by GTK+,
+ * so it shouldn't be modifed or freed.
+ **/
+G_CONST_RETURN gchar *
+gdk_x11_get_xatom_name (Atom xatom)
+{
+ return get_atom_name (gdk_x11_xatom_to_atom (xatom));
}
gboolean
{
Display *xdisplay;
Window xwindow;
+ Atom xproperty;
+ Atom xtype;
Atom ret_prop_type;
gint ret_format;
gulong ret_nitems;
g_return_val_if_fail (!window || GDK_IS_WINDOW (window), FALSE);
+ xproperty = gdk_x11_atom_to_xatom (property);
+ xtype = gdk_x11_atom_to_xatom (type);
+
if (window)
{
if (GDK_WINDOW_DESTROYED (window))
}
ret_data = NULL;
- XGetWindowProperty (xdisplay, xwindow, property,
+ XGetWindowProperty (xdisplay, xwindow, xproperty,
offset, (length + 3) / 4, pdelete,
- type, &ret_prop_type, &ret_format,
+ xtype, &ret_prop_type, &ret_format,
&ret_nitems, &ret_bytes_after,
&ret_data);
}
if (actual_property_type)
- *actual_property_type = ret_prop_type;
+ *actual_property_type = gdk_x11_xatom_to_atom (ret_prop_type);
if (actual_format_type)
*actual_format_type = ret_format;
- if ((type != AnyPropertyType) && (ret_prop_type != type))
+ if ((type != AnyPropertyType) && (ret_prop_type != xtype))
{
- gchar *rn, *pn;
-
XFree (ret_data);
- rn = gdk_atom_name(ret_prop_type);
- pn = gdk_atom_name(type);
- g_warning("Couldn't match property type %s to %s\n", rn, pn);
- g_free(rn); g_free(pn);
+
+ g_warning("Couldn't match property type %s to %s\n",
+ gdk_x11_get_xatom_name (ret_prop_type),
+ gdk_x11_get_xatom_name (xtype));
return FALSE;
}
{
Display *xdisplay;
Window xwindow;
+ Atom xproperty;
+ Atom xtype;
g_return_if_fail (!window || GDK_IS_WINDOW (window));
+ xproperty = gdk_x11_atom_to_xatom (property);
+ xtype = gdk_x11_atom_to_xatom (type);
+
if (window)
{
if (GDK_WINDOW_DESTROYED (window))
xwindow = _gdk_root_window;
}
- XChangeProperty (xdisplay, xwindow, property, type,
+ XChangeProperty (xdisplay, xwindow, xproperty, xtype,
format, mode, (guchar *)data, nelements);
}
xwindow = _gdk_root_window;
}
- XDeleteProperty (xdisplay, xwindow, property);
+ XDeleteProperty (xdisplay, xwindow, gdk_x11_atom_to_xatom (property));
}
while (tmp_list)
{
OwnerInfo *info = tmp_list->data;
- if (info->selection == event->selection)
+ if (info->selection == gdk_x11_xatom_to_atom (event->selection))
{
if ((GDK_DRAWABLE_XID (info->owner) == event->window &&
event->serial >= info->serial))
{
Display *xdisplay;
Window xwindow;
+ Atom xselection;
GSList *tmp_list;
OwnerInfo *info;
+ xselection = gdk_x11_atom_to_xatom (selection);
+
if (owner)
{
if (GDK_WINDOW_DESTROYED (owner))
owner_list = g_slist_prepend (owner_list, info);
}
- XSetSelectionOwner (xdisplay, selection, xwindow, time);
+ XSetSelectionOwner (xdisplay, xselection, xwindow, time);
- return (XGetSelectionOwner (xdisplay, selection) == xwindow);
+ return (XGetSelectionOwner (xdisplay, xselection) == xwindow);
}
GdkWindow*
{
Window xwindow;
- xwindow = XGetSelectionOwner (gdk_display, selection);
+ xwindow = XGetSelectionOwner (gdk_display, gdk_x11_atom_to_xatom (selection));
if (xwindow == None)
return NULL;
if (GDK_WINDOW_DESTROYED (requestor))
return;
- XConvertSelection (GDK_WINDOW_XDISPLAY (requestor), selection, target,
- _gdk_selection_property, GDK_WINDOW_XID (requestor), time);
+ XConvertSelection (GDK_WINDOW_XDISPLAY (requestor),
+ gdk_x11_atom_to_xatom (selection),
+ gdk_x11_atom_to_xatom (target),
+ gdk_x11_atom_to_xatom (_gdk_selection_property),
+ GDK_WINDOW_XID (requestor), time);
}
gint
gulong nitems;
gulong nbytes;
gulong length;
- GdkAtom prop_type;
+ Atom prop_type;
gint prop_format;
guchar *t = NULL;
t = NULL;
XGetWindowProperty (GDK_WINDOW_XDISPLAY (requestor),
GDK_WINDOW_XID (requestor),
- _gdk_selection_property, 0, 0, False,
+ gdk_x11_atom_to_xatom (_gdk_selection_property),
+ 0, 0, False,
AnyPropertyType, &prop_type, &prop_format,
&nitems, &nbytes, &t);
if (ret_type)
- *ret_type = prop_type;
+ *ret_type = gdk_x11_xatom_to_atom (prop_type);
if (ret_format)
*ret_format = prop_format;
Otherwise there's no guarantee we'll win the race ... */
XGetWindowProperty (GDK_DRAWABLE_XDISPLAY (requestor),
GDK_DRAWABLE_XID (requestor),
- _gdk_selection_property, 0, (nbytes + 3) / 4, False,
+ gdk_x11_atom_to_xatom (_gdk_selection_property),
+ 0, (nbytes + 3) / 4, False,
AnyPropertyType, &prop_type, &prop_format,
&nitems, &nbytes, &t);
if (prop_type != None)
{
*data = g_new (guchar, length);
- memcpy (*data, t, length);
+
+ if (prop_type == XA_ATOM)
+ {
+ Atom* atoms = (Atom*) t;
+ GdkAtom* atoms_dest = (GdkAtom*) *data;
+ gint num_atom, i;
+
+ num_atom = (length - 1) / sizeof (GdkAtom);
+ for (i=0; i < num_atom; i++)
+ atoms_dest[i] = gdk_x11_xatom_to_atom (atoms[i]);
+ }
+ else
+ {
+ memcpy (*data, t, length);
+ }
+
if (t)
XFree (t);
return length-1;
xevent.send_event = True;
xevent.display = gdk_display;
xevent.requestor = requestor;
- xevent.selection = selection;
- xevent.target = target;
- xevent.property = property;
+ xevent.selection = gdk_x11_atom_to_xatom (selection);
+ xevent.target = gdk_x11_atom_to_xatom (target);
+ xevent.property = gdk_x11_atom_to_xatom (property);
xevent.time = time;
gdk_send_xevent (requestor, False, NoEventMask, (XEvent*) &xevent);
return 0;
property.value = (guchar *)text;
- property.encoding = encoding;
+ property.encoding = gdk_x11_atom_to_xatom (encoding);
property.format = format;
property.nitems = length;
res = XmbTextPropertyToTextList (GDK_DISPLAY(), &property, list, &count);
}
if (encoding)
- *encoding = property.encoding;
+ *encoding = gdk_x11_xatom_to_atom (property.encoding);
if (format)
*format = property.format;
if (ctext)
gdk_xid_table_insert (&_gdk_root_window, _gdk_parent_root);
}
-static GdkAtom wm_client_leader_atom = GDK_NONE;
+static Atom wm_client_leader_atom = None;
/**
* gdk_window_new:
XSetWMHints (xdisplay, xid, &wm_hints);
if (!wm_client_leader_atom)
- wm_client_leader_atom = gdk_atom_intern ("WM_CLIENT_LEADER", FALSE);
+ wm_client_leader_atom = gdk_x11_get_xatom_by_name ("WM_CLIENT_LEADER");
/* This will set WM_CLIENT_MACHINE and WM_LOCALE_NAME */
XSetWMProperties (xdisplay, xid, NULL, NULL, NULL, 0, NULL, NULL, NULL);
pid = getpid ();
XChangeProperty (xdisplay, xid,
- gdk_atom_intern ("_NET_WM_PID", FALSE),
+ gdk_x11_get_xatom_by_name ("_NET_WM_PID"),
XA_CARDINAL, 32,
PropModeReplace,
(guchar *)&pid, 1);
xevent.type = ClientMessage;
xevent.window = GDK_WINDOW_XID (window);
- xevent.message_type = gdk_atom_intern ("WM_PROTOCOLS", FALSE);
+ xevent.message_type = gdk_x11_get_xatom_by_name ("WM_PROTOCOLS");
xevent.format = 32;
- xevent.data.l[0] = gdk_atom_intern ("WM_DELETE_WINDOW", FALSE);
+ xevent.data.l[0] = gdk_x11_get_xatom_by_name ("WM_DELETE_WINDOW");
xevent.data.l[1] = CurrentTime;
XSendEvent (GDK_WINDOW_XDISPLAY (window),
set_initial_hints (GdkWindow *window)
{
GdkWindowObject *private;
- GdkAtom atoms[5];
+ Atom atoms[5];
gint i;
private = (GdkWindowObject*) window;
if (private->state & GDK_WINDOW_STATE_MAXIMIZED)
{
- atoms[i] = gdk_atom_intern ("_NET_WM_STATE_MAXIMIZED_VERT", FALSE);
+ atoms[i] = gdk_x11_get_xatom_by_name ("_NET_WM_STATE_MAXIMIZED_VERT");
++i;
- atoms[i] = gdk_atom_intern ("_NET_WM_STATE_MAXIMIZED_HORZ", FALSE);
+ atoms[i] = gdk_x11_get_xatom_by_name ("_NET_WM_STATE_MAXIMIZED_HORZ");
++i;
}
if (private->state & GDK_WINDOW_STATE_STICKY)
{
- atoms[i] = gdk_atom_intern ("_NET_WM_STATE_STICKY", FALSE);
+ atoms[i] = gdk_x11_get_xatom_by_name ("_NET_WM_STATE_STICKY");
++i;
}
if (private->modal_hint)
{
- atoms[i] = gdk_atom_intern ("_NET_WM_STATE_MODAL", FALSE);
+ atoms[i] = gdk_x11_get_xatom_by_name ("_NET_WM_STATE_MODAL");
++i;
}
{
XChangeProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
- gdk_atom_intern ("_NET_WM_STATE", FALSE),
+ gdk_x11_get_xatom_by_name ("_NET_WM_STATE"),
XA_ATOM, 32, PropModeReplace,
(guchar*) atoms, i);
}
atoms[0] = 0xFFFFFFFF;
XChangeProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
- gdk_atom_intern ("_NET_WM_DESKTOP", FALSE),
+ gdk_x11_get_xatom_by_name ("_NET_WM_DESKTOP"),
XA_CARDINAL, 32, PropModeReplace,
(guchar*) atoms, 1);
}
xev.xclient.send_event = True;
xev.xclient.window = GDK_WINDOW_XWINDOW (window);
xev.xclient.display = gdk_display;
- xev.xclient.message_type = gdk_atom_intern ("_NET_ACTIVE_WINDOW", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_ACTIVE_WINDOW");
xev.xclient.format = 32;
xev.xclient.data.l[0] = 0;
gdk_window_set_type_hint (GdkWindow *window,
GdkWindowTypeHint hint)
{
- GdkAtom atom;
+ Atom atom;
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
switch (hint)
{
case GDK_WINDOW_TYPE_HINT_DIALOG:
- atom = gdk_atom_intern ("_NET_WM_WINDOW_TYPE_DIALOG", FALSE);
+ atom = gdk_x11_get_xatom_by_name ("_NET_WM_WINDOW_TYPE_DIALOG");
break;
case GDK_WINDOW_TYPE_HINT_MENU:
- atom = gdk_atom_intern ("_NET_WM_WINDOW_TYPE_MENU", FALSE);
+ atom = gdk_x11_get_xatom_by_name ("_NET_WM_WINDOW_TYPE_MENU");
break;
case GDK_WINDOW_TYPE_HINT_TOOLBAR:
- atom = gdk_atom_intern ("_NET_WM_WINDOW_TYPE_TOOLBAR", FALSE);
+ atom = gdk_x11_get_xatom_by_name ("_NET_WM_WINDOW_TYPE_TOOLBAR");
break;
default:
g_warning ("Unknown hint %d passed to gdk_window_set_type_hint", hint);
/* Fall thru */
case GDK_WINDOW_TYPE_HINT_NORMAL:
- atom = gdk_atom_intern ("_NET_WM_WINDOW_TYPE_NORMAL", FALSE);
+ atom = gdk_x11_get_xatom_by_name ("_NET_WM_WINDOW_TYPE_NORMAL");
break;
}
XChangeProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
- gdk_atom_intern ("_NET_WM_WINDOW_TYPE", FALSE),
+ gdk_x11_get_xatom_by_name ("_NET_WM_WINDOW_TYPE"),
XA_ATOM, 32, PropModeReplace,
(guchar *)&atom, 1);
}
static void
-gdk_wmspec_change_state (gboolean add,
+gdk_wmspec_change_state (gboolean add,
GdkWindow *window,
- GdkAtom state1,
- GdkAtom state2)
+ GdkAtom state1,
+ GdkAtom state2)
{
XEvent xev;
xev.xclient.send_event = True;
xev.xclient.display = gdk_display;
xev.xclient.window = GDK_WINDOW_XID (window);
- xev.xclient.message_type = gdk_atom_intern ("_NET_WM_STATE", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_WM_STATE");
xev.xclient.format = 32;
xev.xclient.data.l[0] = add ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
- xev.xclient.data.l[1] = state1;
- xev.xclient.data.l[2] = state2;
+ xev.xclient.data.l[1] = gdk_x11_atom_to_xatom (state1);
+ xev.xclient.data.l[2] = gdk_x11_atom_to_xatom (state2);
XSendEvent (gdk_display, _gdk_root_window, False,
SubstructureRedirectMask | SubstructureNotifyMask,
*/
static void
set_text_property (GdkWindow *window,
- GdkAtom property,
+ Atom property,
const gchar *utf8_str)
{
guchar *prop_text = NULL;
- GdkAtom prop_type;
+ Atom prop_type;
gint prop_length;
gint prop_format;
if (utf8_is_latin1 (utf8_str))
{
- prop_type = GDK_TARGET_STRING;
+ prop_type = XA_STRING;
prop_text = gdk_utf8_to_string_target (utf8_str);
prop_length = strlen (prop_text);
prop_format = 8;
}
else
{
- gdk_utf8_to_compound_text (utf8_str, &prop_type, &prop_format,
+ GdkAtom gdk_type;
+
+ gdk_utf8_to_compound_text (utf8_str, &gdk_type, &prop_format,
&prop_text, &prop_length);
+ prop_type = gdk_x11_atom_to_xatom (gdk_type);
}
if (prop_text)
XChangeProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
- gdk_atom_intern ("_NET_WM_NAME", FALSE),
- gdk_atom_intern ("UTF8_STRING", FALSE), 8,
+ gdk_x11_get_xatom_by_name ("_NET_WM_NAME"),
+ gdk_x11_get_xatom_by_name ("UTF8_STRING"), 8,
PropModeReplace, title,
strlen (title));
- set_text_property (window, gdk_atom_intern ("WM_NAME", FALSE), title);
+ set_text_property (window, gdk_x11_get_xatom_by_name ("WM_NAME"), title);
if (!gdk_window_icon_name_set (window))
{
XChangeProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
- gdk_atom_intern ("_NET_WM_ICON_NAME", FALSE),
- gdk_atom_intern ("UTF8_STRING", FALSE), 8,
+ gdk_x11_get_xatom_by_name ("_NET_WM_ICON_NAME"),
+ gdk_x11_get_xatom_by_name ("UTF8_STRING"), 8,
PropModeReplace, title,
strlen (title));
- set_text_property (window, gdk_atom_intern ("WM_ICON_NAME", FALSE), title);
+ set_text_property (window, gdk_x11_get_xatom_by_name ("WM_ICON_NAME"), title);
}
}
{
if (role)
XChangeProperty (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window),
- gdk_atom_intern ("WM_WINDOW_ROLE", FALSE), XA_STRING,
+ gdk_x11_get_xatom_by_name ("WM_WINDOW_ROLE"), XA_STRING,
8, PropModeReplace, role, strlen (role));
else
XDeleteProperty (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window),
- gdk_atom_intern ("WM_WINDOW_ROLE", FALSE));
+ gdk_x11_get_xatom_by_name ("WM_WINDOW_ROLE"));
}
}
if (!GDK_WINDOW_DESTROYED (window))
{
if (!atom)
- atom = gdk_atom_intern ("ENLIGHTENMENT_DESKTOP", FALSE);
+ atom = gdk_x11_get_xatom_by_name ("ENLIGHTENMENT_DESKTOP");
win = GDK_WINDOW_XID (window);
while (XQueryTree (GDK_WINDOW_XDISPLAY (window), win, &root, &parent,
{
XChangeProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
- gdk_atom_intern ("_NET_WM_ICON", FALSE),
+ gdk_x11_get_xatom_by_name ("_NET_WM_ICON"),
XA_CARDINAL, 32,
PropModeReplace,
(guchar*) data, size);
{
XDeleteProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
- gdk_atom_intern ("_NET_WM_ICON", FALSE));
+ gdk_x11_get_xatom_by_name ("_NET_WM_ICON"));
}
}
XChangeProperty (GDK_WINDOW_XDISPLAY (window),
GDK_WINDOW_XID (window),
- gdk_atom_intern ("_NET_WM_ICON_NAME", FALSE),
- gdk_atom_intern ("UTF8_STRING", FALSE), 8,
+ gdk_x11_get_xatom_by_name ("_NET_WM_ICON_NAME"),
+ gdk_x11_get_xatom_by_name ("UTF8_STRING"), 8,
PropModeReplace, name,
strlen (name));
- set_text_property (window, gdk_atom_intern ("WM_ICON_NAME", FALSE), name);
+ set_text_property (window, gdk_x11_get_xatom_by_name ("WM_ICON_NAME"), name);
}
/**
xev.xclient.send_event = True;
xev.xclient.window = GDK_WINDOW_XWINDOW (window);
xev.xclient.display = gdk_display;
- xev.xclient.message_type = gdk_atom_intern ("_NET_WM_DESKTOP", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_WM_DESKTOP");
xev.xclient.format = 32;
xev.xclient.data.l[0] = 0xFFFFFFFF;
* one that matters much in practice.
*/
XGetWindowProperty (gdk_display, _gdk_root_window,
- gdk_atom_intern ("_NET_CURRENT_DESKTOP", FALSE),
+ gdk_x11_get_xatom_by_name ("_NET_CURRENT_DESKTOP"),
0, G_MAXLONG,
False, XA_CARDINAL, &type, &format, &nitems,
&bytes_after, (guchar **)¤t_desktop);
xev.xclient.send_event = True;
xev.xclient.window = GDK_WINDOW_XWINDOW (window);
xev.xclient.display = gdk_display;
- xev.xclient.message_type = gdk_atom_intern ("_NET_WM_DESKTOP", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_WM_DESKTOP");
xev.xclient.format = 32;
xev.xclient.data.l[0] = *current_desktop;
xev.xclient.send_event = True;
xev.xclient.display = gdk_display;
xev.xclient.window = GDK_WINDOW_XID (window);
- xev.xclient.message_type = gdk_atom_intern ("_NET_WM_MOVERESIZE", FALSE);
+ xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_WM_MOVERESIZE");
xev.xclient.format = 32;
xev.xclient.data.l[0] = root_x;
xev.xclient.data.l[1] = root_y;
/* returns TRUE if we support the given WM spec feature */
gboolean gdk_net_wm_supports (GdkAtom property);
+Atom gdk_x11_atom_to_xatom (GdkAtom atom);
+GdkAtom gdk_x11_xatom_to_atom (Atom xatom);
+Atom gdk_x11_get_xatom_by_name (const gchar *atom_name);
+G_CONST_RETURN gchar *gdk_x11_get_xatom_name (Atom xatom);
+
#ifndef GDK_DISABLE_DEPRECATED
Display * gdk_x11_font_get_xdisplay (GdkFont *font);
list = context->targets;
while (list)
{
- if (atom == GPOINTER_TO_INT (list->data))
+ if (atom == GDK_POINTER_TO_ATOM (list->data))
{
GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
(clist,
list = context->targets;
while (list)
{
- if (atom == GPOINTER_TO_INT (list->data))
+ if (atom == GDK_POINTER_TO_ATOM (list->data))
break;
list = list->next;
}
list = context->targets;
while (list)
{
- if (atom == GPOINTER_TO_INT (list->data))
+ if (atom == GDK_POINTER_TO_ATOM (list->data))
return TRUE;
list = list->next;
}
list = context->targets;
while (list)
{
- if (atom == GPOINTER_TO_INT (list->data))
+ if (atom == GDK_POINTER_TO_ATOM (list->data))
break;
list = list->next;
}
while (tmp_list)
{
gtk_target_list_add (source_info->target_list,
- GPOINTER_TO_UINT (tmp_list->data), 0, 0);
+ GDK_POINTER_TO_ATOM (tmp_list->data), 0, 0);
tmp_list = tmp_list->next;
}
tmp_list = info->selections;
while (tmp_list)
{
- if (GPOINTER_TO_UINT (tmp_list->data) == selection)
+ if (GDK_POINTER_TO_ATOM (tmp_list->data) == selection)
return;
tmp_list = tmp_list->next;
}
GList *tmp_list = info->selections;
while (tmp_list)
{
- GdkAtom selection = GPOINTER_TO_UINT (tmp_list->data);
+ GdkAtom selection = GDK_POINTER_TO_ATOM (tmp_list->data);
if (gdk_selection_owner_get (selection) == info->ipc_widget->window)
gtk_selection_owner_set (NULL, selection, time);
tmp_list = tmp_list->next;
xevent.xclient.window = GDK_WINDOW_XWINDOW (plug->socket_window);
xevent.xclient.type = ClientMessage;
- xevent.xclient.message_type = gdk_atom_intern ("_XEMBED", FALSE);
+ xevent.xclient.message_type = gdk_x11_get_xatom_by_name ("_XEMBED");
xevent.xclient.format = 32;
xevent.xclient.data.l[0] = time;
xevent.xclient.data.l[1] = message;
Window window = GDK_WINDOW_XWINDOW (gdk_window);
unsigned long buffer[2];
- Atom xembed_info_atom = gdk_atom_intern ("_XEMBED_INFO", FALSE);
+ Atom xembed_info_atom = gdk_x11_get_xatom_by_name ("_XEMBED_INFO");
buffer[1] = 0; /* Protocol version */
buffer[1] = flags;
switch (xevent->type)
{
case ClientMessage:
- if (xevent->xclient.message_type == gdk_atom_intern ("_XEMBED", FALSE))
+ if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name ("_XEMBED"))
{
handle_xembed_message (plug,
xevent->xclient.data.l[1],
return GDK_FILTER_REMOVE;
}
- else if (xevent->xclient.message_type == gdk_atom_intern ("WM_DELETE_WINDOW", FALSE))
+ else if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name ("WM_DELETE_WINDOW"))
{
/* We filter these out because we take being reparented back to the
* root window as the reliable end of the embedding protocol
xevent.xclient.window = GDK_WINDOW_XWINDOW (socket->plug_window);
xevent.xclient.type = ClientMessage;
- xevent.xclient.message_type = gdk_atom_intern ("_XEMBED", FALSE);
+ xevent.xclient.message_type = gdk_x11_get_xatom_by_name ("_XEMBED");
xevent.xclient.format = 32;
xevent.xclient.data.l[0] = time;
xevent.xclient.data.l[1] = message;
{
Display *display = GDK_WINDOW_XDISPLAY (gdk_window);
Window window = GDK_WINDOW_XWINDOW (gdk_window);
- Atom xembed_info_atom = gdk_atom_intern ("_XEMBED_INFO", FALSE);
+ Atom xembed_info_atom = gdk_x11_get_xatom_by_name ("_XEMBED_INFO");
Atom type;
int format;
unsigned long nitems, bytes_after;
switch (xevent->type)
{
case ClientMessage:
- if (xevent->xclient.message_type == gdk_atom_intern ("_XEMBED", FALSE))
+ if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name ("_XEMBED"))
{
handle_xembed_message (socket,
xevent->xclient.data.l[1],
{
GdkDragProtocol protocol;
- if ((xevent->xproperty.atom == gdk_atom_intern ("XdndAware", FALSE)) ||
- (xevent->xproperty.atom == gdk_atom_intern ("_MOTIF_DRAG_RECEIVER_INFO", FALSE)))
+ if ((xevent->xproperty.atom == gdk_x11_get_xatom_by_name ("XdndAware")) ||
+ (xevent->xproperty.atom == gdk_x11_get_xatom_by_name ("_MOTIF_DRAG_RECEIVER_INFO")))
{
gdk_error_trap_push ();
if (gdk_drag_get_protocol (xevent->xproperty.window, &protocol))
gdk_flush ();
gdk_error_trap_pop ();
}
- else if (xevent->xproperty.atom == gdk_atom_intern ("_XEMBED_INFO", FALSE))
+ else if (xevent->xproperty.atom == gdk_x11_get_xatom_by_name ("_XEMBED_INFO"))
{
unsigned long flags;
GtkWidget *ancestor;
GdkWindow *window;
- g_return_if_fail (GTK_IS_WIDGET (src_widget));
- g_return_if_fail (GTK_IS_WIDGET (dest_widget));
+ g_return_val_if_fail (GTK_IS_WIDGET (src_widget), FALSE);
+ g_return_val_if_fail (GTK_IS_WIDGET (dest_widget), FALSE);
ancestor = gtk_widget_common_ancestor (src_widget, dest_widget);
if (!ancestor || !GTK_WIDGET_REALIZED (src_widget) || !GTK_WIDGET_REALIZED (dest_widget))
tmp_list = context->targets;
while (tmp_list)
{
- char *name = gdk_atom_name (GPOINTER_TO_UINT (tmp_list->data));
+ char *name = gdk_atom_name (GDK_POINTER_TO_ATOM (tmp_list->data));
g_print ("%s\n", name);
g_free (name);
if (context->targets)
{
gtk_drag_get_data (widget, context,
- GPOINTER_TO_INT (context->targets->data),
+ GDK_POINTER_TO_ATOM (context->targets->data),
time);
return TRUE;
}
if (seltype == SEL_TYPE_NONE)
{
char *name = gdk_atom_name (data->type);
- g_print("Don't know how to handle type: %s (%ld)\n",
- name?name:"<unknown>",
- data->type);
+ g_print("Don't know how to handle type: %s\n",
+ name?name:"<unknown>");
return;
}
default:
{
char *name = gdk_atom_name (data->type);
- g_print("Can't convert type %s (%ld) to string\n",
- name?name:"<unknown>",
- data->type);
+ g_print("Can't convert type %s to string\n",
+ name?name:"<unknown>");
position = data->length;
continue;
}
projects / gtk4.git / commitdiff